<?xml version='1.0' encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="en" xml:lang="en" xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <link href="cpip.css" rel="stylesheet" type="text/css" />
    <title>File: /Users/paulross/dev/linux/linux-3.13/include/linux/seqlock.h</title>
  </head>
  <body>
    <h1>File: /Users/paulross/dev/linux/linux-3.13/include/linux/seqlock.h</h1>
    <p>Green shading in the line number column
means the source is part of the translation unit, red means it is conditionally excluded.
Highlighted line numbers link to the translation unit page. Highlighted macros link to
the macro page.</p>
    <pre><a name="1" /><span class="Maybe">       1:</span> <span class="f">#</span><span class="n">ifndef</span> <a href="cpu.c_macros_ref.html#_X19MSU5VWF9TRVFMT0NLX0hfMA__"><span class="b">__LINUX_SEQLOCK_H</span></a>
<a name="2" /><span class="Maybe">       2:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_ref.html#_X19MSU5VWF9TRVFMT0NLX0hfMA__"><span class="b">__LINUX_SEQLOCK_H</span></a>
<a name="3" /><span class="Maybe">       3:</span> <span class="k">/*</span>
<a name="4" /><span class="Maybe">       4:</span> <span class="k"> * Reader/writer consistent mechanism without starving writers. This type of</span>
<a name="5" /><span class="Maybe">       5:</span> <span class="k"> * lock for data where the reader wants a consistent set of information</span>
<a name="6" /><span class="Maybe">       6:</span> <span class="k"> * and is willing to retry if the information changes. There are two types</span>
<a name="7" /><span class="Maybe">       7:</span> <span class="k"> * of readers:</span>
<a name="8" /><span class="Maybe">       8:</span> <span class="k"> * 1. Sequence readers which never block a writer but they may have to retry</span>
<a name="9" /><span class="Maybe">       9:</span> <span class="k"> *    if a writer is in progress by detecting change in sequence number.</span>
<a name="10" /><span class="Maybe">      10:</span> <span class="k"> *    Writers do not wait for a sequence reader.</span>
<a name="11" /><span class="Maybe">      11:</span> <span class="k"> * 2. Locking readers which will wait if a writer or another locking reader</span>
<a name="12" /><span class="Maybe">      12:</span> <span class="k"> *    is in progress. A locking reader in progress will also block a writer</span>
<a name="13" /><span class="Maybe">      13:</span> <span class="k"> *    from going forward. Unlike the regular rwlock, the read lock here is</span>
<a name="14" /><span class="Maybe">      14:</span> <span class="k"> *    exclusive so that only one locking reader can get it.</span>
<a name="15" /><span class="Maybe">      15:</span> <span class="k"> *</span>
<a name="16" /><span class="Maybe">      16:</span> <span class="k"> * This is not as cache friendly as brlock. Also, this may not work well</span>
<a name="17" /><span class="Maybe">      17:</span> <span class="k"> * for data that contains pointers, because any writer could</span>
<a name="18" /><span class="Maybe">      18:</span> <span class="k"> * invalidate a pointer that a reader was following.</span>
<a name="19" /><span class="Maybe">      19:</span> <span class="k"> *</span>
<a name="20" /><span class="Maybe">      20:</span> <span class="k"> * Expected non-blocking reader usage:</span>
<a name="21" /><span class="Maybe">      21:</span> <span class="k"> *     do {</span>
<a name="22" /><span class="Maybe">      22:</span> <span class="k"> *        seq = read_seqbegin(&amp;foo);</span>
<a name="23" /><span class="Maybe">      23:</span> <span class="k"> *     ...</span>
<a name="24" /><span class="Maybe">      24:</span> <span class="k"> *      } while (read_seqretry(&amp;foo, seq));</span>
<a name="25" /><span class="Maybe">      25:</span> <span class="k"> *</span>
<a name="26" /><span class="Maybe">      26:</span> <span class="k"> *</span>
<a name="27" /><span class="Maybe">      27:</span> <span class="k"> * On non-SMP the spin locks disappear but the writer still needs</span>
<a name="28" /><span class="Maybe">      28:</span> <span class="k"> * to increment the sequence variables because an interrupt routine could</span>
<a name="29" /><span class="Maybe">      29:</span> <span class="k"> * change the state of the data.</span>
<a name="30" /><span class="Maybe">      30:</span> <span class="k"> *</span>
<a name="31" /><span class="Maybe">      31:</span> <span class="k"> * Based on x86_64 vsyscall gettimeofday </span>
<a name="32" /><span class="Maybe">      32:</span> <span class="k"> * by Keith Owens and Andrea Arcangeli</span>
<a name="33" /><span class="Maybe">      33:</span> <span class="k"> */</span>
<a name="34" /><span class="Maybe">      34:</span> 
<a name="35" /><span class="Maybe">      35:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">spinlock</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="36" /><span class="Maybe">      36:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">preempt</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="37" /><span class="Maybe">      37:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="b">linux</span><span class="f">/</span><span class="b">lockdep</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="38" /><span class="Maybe">      38:</span> <span class="f">#</span><span class="n">include</span> <span class="f">&lt;</span><span class="m">asm</span><span class="f">/</span><span class="b">processor</span><span class="f">.</span><span class="b">h</span><span class="f">&gt;</span>
<a name="39" /><span class="Maybe">      39:</span> 
<a name="40" /><span class="Maybe">      40:</span> <span class="k">/*</span>
<a name="41" /><span class="Maybe">      41:</span> <span class="k"> * Version using sequence counter only.</span>
<a name="42" /><span class="Maybe">      42:</span> <span class="k"> * This can be used when code has its own mutex protecting the</span>
<a name="43" /><span class="Maybe">      43:</span> <span class="k"> * updating starting before the write_seqcountbeqin() and ending</span>
<a name="44" /><span class="Maybe">      44:</span> <span class="k"> * after the write_seqcount_end().</span>
<a name="45" /><span class="Maybe">      45:</span> <span class="k"> */</span>
<a name="46" /><span class="Maybe">      46:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="b">seqcount</span> <span class="f">{</span>
<a name="47" /><span class="Maybe">      47:</span>     <span class="m">unsigned</span> <span class="b">sequence</span><span class="f">;</span>
<a name="48" /><span class="False">      48:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">CONFIG_DEBUG_LOCK_ALLOC</span>
<a name="49" /><span class="False">      49:</span>     <span class="m">struct</span> <span class="b">lockdep_map</span> <span class="b">dep_map</span><span class="f">;</span>
<a name="50" /><span class="Maybe">      50:</span> <span class="f">#</span><span class="n">endif</span>
<a name="51" /><span class="Maybe">      51:</span> <span class="f">}</span> <span class="b">seqcount_t</span><span class="f">;</span>
<a name="52" /><span class="Maybe">      52:</span> 
<a name="53" /><span class="Maybe">      53:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">__seqcount_init</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">,</span> <span class="m">const</span> <span class="m">char</span> <span class="f">*</span><span class="b">name</span><span class="f">,</span>
<a name="54" /><span class="Maybe">      54:</span>                       <span class="m">struct</span> <span class="b">lock_class_key</span> <span class="f">*</span><span class="b">key</span><span class="f">)</span>
<a name="55" /><span class="Maybe">      55:</span> <span class="f">{</span>
<a name="56" /><span class="Maybe">      56:</span>     <span class="k">/*</span>
<a name="57" /><span class="Maybe">      57:</span> <span class="k">     * Make sure we are not reinitializing a held lock:</span>
<a name="58" /><span class="Maybe">      58:</span> <span class="k">     */</span>
<a name="59" /><span class="Maybe">      59:</span>     <a href="cpu.c_macros_ref.html#_bG9ja2RlcF9pbml0X21hcF8w"><span class="b">lockdep_init_map</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">s</span><span class="f">-&gt;</span><span class="b">dep_map</span><span class="f">,</span> <span class="b">name</span><span class="f">,</span> <span class="b">key</span><span class="f">,</span> <span class="c">0</span><span class="f">)</span><span class="f">;</span>
<a name="60" /><span class="Maybe">      60:</span>     <span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span> <span class="f">=</span> <span class="c">0</span><span class="f">;</span>
<a name="61" /><span class="Maybe">      61:</span> <span class="f">}</span>
<a name="62" /><span class="Maybe">      62:</span> 
<a name="63" /><span class="False">      63:</span> <span class="f">#</span><span class="n">ifdef</span> <span class="b">CONFIG_DEBUG_LOCK_ALLOC</span>
<a name="64" /><span class="False">      64:</span> <span class="f">#</span> <span class="n">define</span> <a href="cpu.c_macros_noref.html#_U0VRQ09VTlRfREVQX01BUF9JTklUXzA_"><span class="b">SEQCOUNT_DEP_MAP_INIT</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span> \
<a name="65" /><span class="False">      65:</span>         <span class="f">.</span><span class="b">dep_map</span> <span class="f">=</span> <span class="f">{</span> <span class="f">.</span><span class="b">name</span> <span class="f">=</span> <span class="f">#</span><span class="b">lockname</span> <span class="f">}</span> \
<a name="66" /><span class="False">      66:</span> 
<a name="67" /><span class="False">      67:</span> <span class="f">#</span> <span class="n">define</span> <a href="cpu.c_macros_noref.html#_c2VxY291bnRfaW5pdF8w"><span class="b">seqcount_init</span></a><span class="f">(</span><span class="b">s</span><span class="f">)</span>                \
<a name="68" /><span class="False">      68:</span>     <span class="m">do</span> <span class="f">{</span>                        \
<a name="69" /><span class="False">      69:</span>         <span class="m">static</span> <span class="m">struct</span> <span class="b">lock_class_key</span> <span class="b">__key</span><span class="f">;</span>    \
<a name="70" /><span class="False">      70:</span>         <span class="b">__seqcount_init</span><span class="f">(</span><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">,</span> <span class="f">#</span><span class="b">s</span><span class="f">,</span> <span class="f">&amp;</span><span class="b">__key</span><span class="f">)</span><span class="f">;</span>    \
<a name="71" /><span class="False">      71:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="72" /><span class="False">      72:</span> 
<a name="73" /><span class="False">      73:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <a href="cpu.c_macros_ref.html#_c2VxY291bnRfbG9ja2RlcF9yZWFkZXJfYWNjZXNzXzA_"><span class="b">seqcount_lockdep_reader_access</span></a><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="74" /><span class="False">      74:</span> <span class="f">{</span>
<a name="75" /><span class="False">      75:</span>     <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">l</span> <span class="f">=</span> <span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="f">)</span><span class="b">s</span><span class="f">;</span>
<a name="76" /><span class="False">      76:</span>     <span class="m">unsigned</span> <span class="m">long</span> <span class="b">flags</span><span class="f">;</span>
<a name="77" /><span class="False">      77:</span> 
<a name="78" /><span class="False">      78:</span>     <a href="cpu.c_macros_ref.html#_bG9jYWxfaXJxX3NhdmVfMA__"><span class="b">local_irq_save</span></a><span class="f">(</span><span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="79" /><span class="False">      79:</span>     <a href="cpu.c_macros_noref.html#_c2VxY291bnRfYWNxdWlyZV9yZWFkXzA_"><span class="b">seqcount_acquire_read</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">l</span><span class="f">-&gt;</span><span class="b">dep_map</span><span class="f">,</span> <span class="c">0</span><span class="f">,</span> <span class="c">0</span><span class="f">,</span> <a href="cpu.c_macros_ref.html#_X1JFVF9JUF9fMA__"><span class="b">_RET_IP_</span></a><span class="f">)</span><span class="f">;</span>
<a name="80" /><span class="False">      80:</span>     <a href="cpu.c_macros_ref.html#_c2VxY291bnRfcmVsZWFzZV8w"><span class="b">seqcount_release</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">l</span><span class="f">-&gt;</span><span class="b">dep_map</span><span class="f">,</span> <span class="c">1</span><span class="f">,</span> <a href="cpu.c_macros_ref.html#_X1JFVF9JUF9fMA__"><span class="b">_RET_IP_</span></a><span class="f">)</span><span class="f">;</span>
<a name="81" /><span class="False">      81:</span>     <a href="cpu.c_macros_ref.html#_bG9jYWxfaXJxX3Jlc3RvcmVfMA__"><span class="b">local_irq_restore</span></a><span class="f">(</span><span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="82" /><span class="False">      82:</span> <span class="f">}</span>
<a name="83" /><span class="False">      83:</span> 
<a name="84" /><span class="Maybe">      84:</span> <span class="f">#</span><span class="n">else</span>
<a name="85" /><span class="Maybe">      85:</span> <span class="f">#</span> <span class="n">define</span> <a href="cpu.c_macros_noref.html#_U0VRQ09VTlRfREVQX01BUF9JTklUXzA_"><span class="b">SEQCOUNT_DEP_MAP_INIT</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span>
<a name="86" /><span class="Maybe">      86:</span> <span class="f">#</span> <span class="n">define</span> <a href="cpu.c_macros_noref.html#_c2VxY291bnRfaW5pdF8w"><span class="b">seqcount_init</span></a><span class="f">(</span><span class="b">s</span><span class="f">)</span> <span class="b">__seqcount_init</span><span class="f">(</span><span class="b">s</span><span class="f">,</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">,</span> <a href="cpu.c_macros_ref.html#_TlVMTF8w"><span class="b">NULL</span></a><span class="f">)</span>
<a name="87" /><span class="Maybe">      87:</span> <span class="f">#</span> <span class="n">define</span> <a href="cpu.c_macros_ref.html#_c2VxY291bnRfbG9ja2RlcF9yZWFkZXJfYWNjZXNzXzA_"><span class="b">seqcount_lockdep_reader_access</span></a><span class="f">(</span><span class="b">x</span><span class="f">)</span>
<a name="88" /><span class="Maybe">      88:</span> <span class="f">#</span><span class="n">endif</span>
<a name="89" /><span class="Maybe">      89:</span> 
<a name="90" /><span class="Maybe">      90:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_U0VRQ05UX1pFUk9fMA__"><span class="b">SEQCNT_ZERO</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span> <span class="f">{</span> <span class="f">.</span><span class="b">sequence</span> <span class="f">=</span> <span class="c">0</span><span class="f">,</span> <a href="cpu.c_macros_noref.html#_U0VRQ09VTlRfREVQX01BUF9JTklUXzA_"><span class="b">SEQCOUNT_DEP_MAP_INIT</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span><span class="f">}</span>
<a name="91" /><span class="Maybe">      91:</span> 
<a name="92" /><span class="Maybe">      92:</span> 
<a name="93" /><span class="Maybe">      93:</span> <span class="k">/**</span>
<a name="94" /><span class="Maybe">      94:</span> <span class="k"> * __read_seqcount_begin - begin a seq-read critical section (without barrier)</span>
<a name="95" /><span class="Maybe">      95:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="96" /><span class="Maybe">      96:</span> <span class="k"> * Returns: count to be passed to read_seqcount_retry</span>
<a name="97" /><span class="Maybe">      97:</span> <span class="k"> *</span>
<a name="98" /><span class="Maybe">      98:</span> <span class="k"> * __read_seqcount_begin is like read_seqcount_begin, but has no smp_rmb()</span>
<a name="99" /><span class="Maybe">      99:</span> <span class="k"> * barrier. Callers should ensure that smp_rmb() or equivalent ordering is</span>
<a name="100" /><span class="Maybe">     100:</span> <span class="k"> * provided before actually loading any of the variables that are to be</span>
<a name="101" /><span class="Maybe">     101:</span> <span class="k"> * protected in this critical section.</span>
<a name="102" /><span class="Maybe">     102:</span> <span class="k"> *</span>
<a name="103" /><span class="Maybe">     103:</span> <span class="k"> * Use carefully, only in critical code, and comment how the barrier is</span>
<a name="104" /><span class="Maybe">     104:</span> <span class="k"> * provided.</span>
<a name="105" /><span class="Maybe">     105:</span> <span class="k"> */</span>
<a name="106" /><span class="Maybe">     106:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="b">__read_seqcount_begin</span><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="107" /><span class="Maybe">     107:</span> <span class="f">{</span>
<a name="108" /><span class="Maybe">     108:</span>     <span class="m">unsigned</span> <span class="b">ret</span><span class="f">;</span>
<a name="109" /><span class="Maybe">     109:</span> 
<a name="110" /><span class="Maybe">     110:</span> <span class="b">repeat</span><span class="f">:</span>
<a name="111" /><span class="Maybe">     111:</span>     <span class="b">ret</span> <span class="f">=</span> <a href="cpu.c_macros_ref.html#_QUNDRVNTX09OQ0VfMA__"><span class="b">ACCESS_ONCE</span></a><span class="f">(</span><span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span><span class="f">)</span><span class="f">;</span>
<a name="112" /><span class="Maybe">     112:</span>     <span class="m">if</span> <span class="f">(</span><a href="cpu.c_macros_ref.html#_dW5saWtlbHlfMA__"><span class="b">unlikely</span></a><span class="f">(</span><span class="b">ret</span> <span class="f">&amp;</span> <span class="c">1</span><span class="f">)</span><span class="f">)</span> <span class="f">{</span>
<a name="113" /><span class="Maybe">     113:</span>         <span class="b">cpu_relax</span><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="114" /><span class="Maybe">     114:</span>         <span class="m">goto</span> <span class="b">repeat</span><span class="f">;</span>
<a name="115" /><span class="Maybe">     115:</span>     <span class="f">}</span>
<a name="116" /><span class="Maybe">     116:</span>     <span class="m">return</span> <span class="b">ret</span><span class="f">;</span>
<a name="117" /><span class="Maybe">     117:</span> <span class="f">}</span>
<a name="118" /><span class="Maybe">     118:</span> 
<a name="119" /><span class="Maybe">     119:</span> <span class="k">/**</span>
<a name="120" /><span class="Maybe">     120:</span> <span class="k"> * raw_read_seqcount_begin - start seq-read critical section w/o lockdep</span>
<a name="121" /><span class="Maybe">     121:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="122" /><span class="Maybe">     122:</span> <span class="k"> * Returns: count to be passed to read_seqcount_retry</span>
<a name="123" /><span class="Maybe">     123:</span> <span class="k"> *</span>
<a name="124" /><span class="Maybe">     124:</span> <span class="k"> * raw_read_seqcount_begin opens a read critical section of the given</span>
<a name="125" /><span class="Maybe">     125:</span> <span class="k"> * seqcount, but without any lockdep checking. Validity of the critical</span>
<a name="126" /><span class="Maybe">     126:</span> <span class="k"> * section is tested by checking read_seqcount_retry function.</span>
<a name="127" /><span class="Maybe">     127:</span> <span class="k"> */</span>
<a name="128" /><span class="Maybe">     128:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="b">raw_read_seqcount_begin</span><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="129" /><span class="Maybe">     129:</span> <span class="f">{</span>
<a name="130" /><span class="Maybe">     130:</span>     <span class="m">unsigned</span> <span class="b">ret</span> <span class="f">=</span> <span class="b">__read_seqcount_begin</span><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">;</span>
<a name="131" /><span class="Maybe">     131:</span>     <a href="cpu.c_macros_ref.html#_c21wX3JtYl8w"><span class="b">smp_rmb</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="132" /><span class="Maybe">     132:</span>     <span class="m">return</span> <span class="b">ret</span><span class="f">;</span>
<a name="133" /><span class="Maybe">     133:</span> <span class="f">}</span>
<a name="134" /><span class="Maybe">     134:</span> 
<a name="135" /><span class="Maybe">     135:</span> <span class="k">/**</span>
<a name="136" /><span class="Maybe">     136:</span> <span class="k"> * read_seqcount_begin - begin a seq-read critical section</span>
<a name="137" /><span class="Maybe">     137:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="138" /><span class="Maybe">     138:</span> <span class="k"> * Returns: count to be passed to read_seqcount_retry</span>
<a name="139" /><span class="Maybe">     139:</span> <span class="k"> *</span>
<a name="140" /><span class="Maybe">     140:</span> <span class="k"> * read_seqcount_begin opens a read critical section of the given seqcount.</span>
<a name="141" /><span class="Maybe">     141:</span> <span class="k"> * Validity of the critical section is tested by checking read_seqcount_retry</span>
<a name="142" /><span class="Maybe">     142:</span> <span class="k"> * function.</span>
<a name="143" /><span class="Maybe">     143:</span> <span class="k"> */</span>
<a name="144" /><span class="Maybe">     144:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="b">read_seqcount_begin</span><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="145" /><span class="Maybe">     145:</span> <span class="f">{</span>
<a name="146" /><span class="Maybe">     146:</span>     <a href="cpu.c_macros_ref.html#_c2VxY291bnRfbG9ja2RlcF9yZWFkZXJfYWNjZXNzXzA_"><span class="b">seqcount_lockdep_reader_access</span></a><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">;</span>
<a name="147" /><span class="Maybe">     147:</span>     <span class="m">return</span> <span class="b">raw_read_seqcount_begin</span><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">;</span>
<a name="148" /><span class="Maybe">     148:</span> <span class="f">}</span>
<a name="149" /><span class="Maybe">     149:</span> 
<a name="150" /><span class="Maybe">     150:</span> <span class="k">/**</span>
<a name="151" /><span class="Maybe">     151:</span> <span class="k"> * raw_seqcount_begin - begin a seq-read critical section</span>
<a name="152" /><span class="Maybe">     152:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="153" /><span class="Maybe">     153:</span> <span class="k"> * Returns: count to be passed to read_seqcount_retry</span>
<a name="154" /><span class="Maybe">     154:</span> <span class="k"> *</span>
<a name="155" /><span class="Maybe">     155:</span> <span class="k"> * raw_seqcount_begin opens a read critical section of the given seqcount.</span>
<a name="156" /><span class="Maybe">     156:</span> <span class="k"> * Validity of the critical section is tested by checking read_seqcount_retry</span>
<a name="157" /><span class="Maybe">     157:</span> <span class="k"> * function.</span>
<a name="158" /><span class="Maybe">     158:</span> <span class="k"> *</span>
<a name="159" /><span class="Maybe">     159:</span> <span class="k"> * Unlike read_seqcount_begin(), this function will not wait for the count</span>
<a name="160" /><span class="Maybe">     160:</span> <span class="k"> * to stabilize. If a writer is active when we begin, we will fail the</span>
<a name="161" /><span class="Maybe">     161:</span> <span class="k"> * read_seqcount_retry() instead of stabilizing at the beginning of the</span>
<a name="162" /><span class="Maybe">     162:</span> <span class="k"> * critical section.</span>
<a name="163" /><span class="Maybe">     163:</span> <span class="k"> */</span>
<a name="164" /><span class="Maybe">     164:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="b">raw_seqcount_begin</span><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="165" /><span class="Maybe">     165:</span> <span class="f">{</span>
<a name="166" /><span class="Maybe">     166:</span>     <span class="m">unsigned</span> <span class="b">ret</span> <span class="f">=</span> <a href="cpu.c_macros_ref.html#_QUNDRVNTX09OQ0VfMA__"><span class="b">ACCESS_ONCE</span></a><span class="f">(</span><span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span><span class="f">)</span><span class="f">;</span>
<a name="167" /><span class="Maybe">     167:</span> 
<a name="168" /><span class="Maybe">     168:</span>     <a href="cpu.c_macros_ref.html#_c2VxY291bnRfbG9ja2RlcF9yZWFkZXJfYWNjZXNzXzA_"><span class="b">seqcount_lockdep_reader_access</span></a><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">;</span>
<a name="169" /><span class="Maybe">     169:</span>     <a href="cpu.c_macros_ref.html#_c21wX3JtYl8w"><span class="b">smp_rmb</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="170" /><span class="Maybe">     170:</span>     <span class="m">return</span> <span class="b">ret</span> <span class="f">&amp;</span> <span class="f">~</span><span class="c">1</span><span class="f">;</span>
<a name="171" /><span class="Maybe">     171:</span> <span class="f">}</span>
<a name="172" /><span class="Maybe">     172:</span> 
<a name="173" /><span class="Maybe">     173:</span> <span class="k">/**</span>
<a name="174" /><span class="Maybe">     174:</span> <span class="k"> * __read_seqcount_retry - end a seq-read critical section (without barrier)</span>
<a name="175" /><span class="Maybe">     175:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="176" /><span class="Maybe">     176:</span> <span class="k"> * @start: count, from read_seqcount_begin</span>
<a name="177" /><span class="Maybe">     177:</span> <span class="k"> * Returns: 1 if retry is required, else 0</span>
<a name="178" /><span class="Maybe">     178:</span> <span class="k"> *</span>
<a name="179" /><span class="Maybe">     179:</span> <span class="k"> * __read_seqcount_retry is like read_seqcount_retry, but has no smp_rmb()</span>
<a name="180" /><span class="Maybe">     180:</span> <span class="k"> * barrier. Callers should ensure that smp_rmb() or equivalent ordering is</span>
<a name="181" /><span class="Maybe">     181:</span> <span class="k"> * provided before actually loading any of the variables that are to be</span>
<a name="182" /><span class="Maybe">     182:</span> <span class="k"> * protected in this critical section.</span>
<a name="183" /><span class="Maybe">     183:</span> <span class="k"> *</span>
<a name="184" /><span class="Maybe">     184:</span> <span class="k"> * Use carefully, only in critical code, and comment how the barrier is</span>
<a name="185" /><span class="Maybe">     185:</span> <span class="k"> * provided.</span>
<a name="186" /><span class="Maybe">     186:</span> <span class="k"> */</span>
<a name="187" /><span class="Maybe">     187:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">__read_seqcount_retry</span><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">,</span> <span class="m">unsigned</span> <span class="b">start</span><span class="f">)</span>
<a name="188" /><span class="Maybe">     188:</span> <span class="f">{</span>
<a name="189" /><span class="Maybe">     189:</span>     <span class="m">return</span> <a href="cpu.c_macros_ref.html#_dW5saWtlbHlfMA__"><span class="b">unlikely</span></a><span class="f">(</span><span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span> <span class="f">!=</span> <span class="b">start</span><span class="f">)</span><span class="f">;</span>
<a name="190" /><span class="Maybe">     190:</span> <span class="f">}</span>
<a name="191" /><span class="Maybe">     191:</span> 
<a name="192" /><span class="Maybe">     192:</span> <span class="k">/**</span>
<a name="193" /><span class="Maybe">     193:</span> <span class="k"> * read_seqcount_retry - end a seq-read critical section</span>
<a name="194" /><span class="Maybe">     194:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="195" /><span class="Maybe">     195:</span> <span class="k"> * @start: count, from read_seqcount_begin</span>
<a name="196" /><span class="Maybe">     196:</span> <span class="k"> * Returns: 1 if retry is required, else 0</span>
<a name="197" /><span class="Maybe">     197:</span> <span class="k"> *</span>
<a name="198" /><span class="Maybe">     198:</span> <span class="k"> * read_seqcount_retry closes a read critical section of the given seqcount.</span>
<a name="199" /><span class="Maybe">     199:</span> <span class="k"> * If the critical section was invalid, it must be ignored (and typically</span>
<a name="200" /><span class="Maybe">     200:</span> <span class="k"> * retried).</span>
<a name="201" /><span class="Maybe">     201:</span> <span class="k"> */</span>
<a name="202" /><span class="Maybe">     202:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">read_seqcount_retry</span><span class="f">(</span><span class="m">const</span> <span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">,</span> <span class="m">unsigned</span> <span class="b">start</span><span class="f">)</span>
<a name="203" /><span class="Maybe">     203:</span> <span class="f">{</span>
<a name="204" /><span class="Maybe">     204:</span>     <a href="cpu.c_macros_ref.html#_c21wX3JtYl8w"><span class="b">smp_rmb</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="205" /><span class="Maybe">     205:</span>     <span class="m">return</span> <span class="b">__read_seqcount_retry</span><span class="f">(</span><span class="b">s</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span><span class="f">;</span>
<a name="206" /><span class="Maybe">     206:</span> <span class="f">}</span>
<a name="207" /><span class="Maybe">     207:</span> 
<a name="208" /><span class="Maybe">     208:</span> 
<a name="209" /><span class="Maybe">     209:</span> 
<a name="210" /><span class="Maybe">     210:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">raw_write_seqcount_begin</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="211" /><span class="Maybe">     211:</span> <span class="f">{</span>
<a name="212" /><span class="Maybe">     212:</span>     <span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span><span class="f">++</span><span class="f">;</span>
<a name="213" /><span class="Maybe">     213:</span>     <a href="cpu.c_macros_ref.html#_c21wX3dtYl8w"><span class="b">smp_wmb</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="214" /><span class="Maybe">     214:</span> <span class="f">}</span>
<a name="215" /><span class="Maybe">     215:</span> 
<a name="216" /><span class="Maybe">     216:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">raw_write_seqcount_end</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="217" /><span class="Maybe">     217:</span> <span class="f">{</span>
<a name="218" /><span class="Maybe">     218:</span>     <a href="cpu.c_macros_ref.html#_c21wX3dtYl8w"><span class="b">smp_wmb</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="219" /><span class="Maybe">     219:</span>     <span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span><span class="f">++</span><span class="f">;</span>
<a name="220" /><span class="Maybe">     220:</span> <span class="f">}</span>
<a name="221" /><span class="Maybe">     221:</span> 
<a name="222" /><span class="Maybe">     222:</span> <span class="k">/*</span>
<a name="223" /><span class="Maybe">     223:</span> <span class="k"> * Sequence counter only version assumes that callers are using their</span>
<a name="224" /><span class="Maybe">     224:</span> <span class="k"> * own mutexing.</span>
<a name="225" /><span class="Maybe">     225:</span> <span class="k"> */</span>
<a name="226" /><span class="Maybe">     226:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqcount_begin_nested</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">,</span> <span class="m">int</span> <span class="b">subclass</span><span class="f">)</span>
<a name="227" /><span class="Maybe">     227:</span> <span class="f">{</span>
<a name="228" /><span class="Maybe">     228:</span>     <span class="b">raw_write_seqcount_begin</span><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">;</span>
<a name="229" /><span class="Maybe">     229:</span>     <a href="cpu.c_macros_ref.html#_c2VxY291bnRfYWNxdWlyZV8w"><span class="b">seqcount_acquire</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">s</span><span class="f">-&gt;</span><span class="b">dep_map</span><span class="f">,</span> <span class="b">subclass</span><span class="f">,</span> <span class="c">0</span><span class="f">,</span> <a href="cpu.c_macros_ref.html#_X1JFVF9JUF9fMA__"><span class="b">_RET_IP_</span></a><span class="f">)</span><span class="f">;</span>
<a name="230" /><span class="Maybe">     230:</span> <span class="f">}</span>
<a name="231" /><span class="Maybe">     231:</span> 
<a name="232" /><span class="Maybe">     232:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqcount_begin</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="233" /><span class="Maybe">     233:</span> <span class="f">{</span>
<a name="234" /><span class="Maybe">     234:</span>     <span class="b">write_seqcount_begin_nested</span><span class="f">(</span><span class="b">s</span><span class="f">,</span> <span class="c">0</span><span class="f">)</span><span class="f">;</span>
<a name="235" /><span class="Maybe">     235:</span> <span class="f">}</span>
<a name="236" /><span class="Maybe">     236:</span> 
<a name="237" /><span class="Maybe">     237:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqcount_end</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="238" /><span class="Maybe">     238:</span> <span class="f">{</span>
<a name="239" /><span class="Maybe">     239:</span>     <a href="cpu.c_macros_ref.html#_c2VxY291bnRfcmVsZWFzZV8w"><span class="b">seqcount_release</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">s</span><span class="f">-&gt;</span><span class="b">dep_map</span><span class="f">,</span> <span class="c">1</span><span class="f">,</span> <a href="cpu.c_macros_ref.html#_X1JFVF9JUF9fMA__"><span class="b">_RET_IP_</span></a><span class="f">)</span><span class="f">;</span>
<a name="240" /><span class="Maybe">     240:</span>     <span class="b">raw_write_seqcount_end</span><span class="f">(</span><span class="b">s</span><span class="f">)</span><span class="f">;</span>
<a name="241" /><span class="Maybe">     241:</span> <span class="f">}</span>
<a name="242" /><span class="Maybe">     242:</span> 
<a name="243" /><span class="Maybe">     243:</span> <span class="k">/**</span>
<a name="244" /><span class="Maybe">     244:</span> <span class="k"> * write_seqcount_barrier - invalidate in-progress read-side seq operations</span>
<a name="245" /><span class="Maybe">     245:</span> <span class="k"> * @s: pointer to seqcount_t</span>
<a name="246" /><span class="Maybe">     246:</span> <span class="k"> *</span>
<a name="247" /><span class="Maybe">     247:</span> <span class="k"> * After write_seqcount_barrier, no read-side seq operations will complete</span>
<a name="248" /><span class="Maybe">     248:</span> <span class="k"> * successfully and see data older than this.</span>
<a name="249" /><span class="Maybe">     249:</span> <span class="k"> */</span>
<a name="250" /><span class="Maybe">     250:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqcount_barrier</span><span class="f">(</span><span class="b">seqcount_t</span> <span class="f">*</span><span class="b">s</span><span class="f">)</span>
<a name="251" /><span class="Maybe">     251:</span> <span class="f">{</span>
<a name="252" /><span class="Maybe">     252:</span>     <a href="cpu.c_macros_ref.html#_c21wX3dtYl8w"><span class="b">smp_wmb</span></a><span class="f">(</span><span class="f">)</span><span class="f">;</span>
<a name="253" /><span class="Maybe">     253:</span>     <span class="b">s</span><span class="f">-&gt;</span><span class="b">sequence</span><span class="f">+=</span><span class="c">2</span><span class="f">;</span>
<a name="254" /><span class="Maybe">     254:</span> <span class="f">}</span>
<a name="255" /><span class="Maybe">     255:</span> 
<a name="256" /><span class="Maybe">     256:</span> <span class="m">typedef</span> <span class="m">struct</span> <span class="f">{</span>
<a name="257" /><span class="Maybe">     257:</span>     <span class="m">struct</span> <span class="b">seqcount</span> <span class="b">seqcount</span><span class="f">;</span>
<a name="258" /><span class="Maybe">     258:</span>     <span class="b">spinlock_t</span> <span class="b">lock</span><span class="f">;</span>
<a name="259" /><span class="Maybe">     259:</span> <span class="f">}</span> <span class="b">seqlock_t</span><span class="f">;</span>
<a name="260" /><span class="Maybe">     260:</span> 
<a name="261" /><span class="Maybe">     261:</span> <span class="k">/*</span>
<a name="262" /><span class="Maybe">     262:</span> <span class="k"> * These macros triggered gcc-3.x compile-time problems.  We think these are</span>
<a name="263" /><span class="Maybe">     263:</span> <span class="k"> * OK now.  Be cautious.</span>
<a name="264" /><span class="Maybe">     264:</span> <span class="k"> */</span>
<a name="265" /><span class="Maybe">     265:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_X19TRVFMT0NLX1VOTE9DS0VEXzA_"><span class="b">__SEQLOCK_UNLOCKED</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span>            \
<a name="266" /><span class="Maybe">     266:</span>     <span class="f">{</span>                        \
<a name="267" /><span class="Maybe">     267:</span>         <span class="f">.</span><span class="b">seqcount</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_U0VRQ05UX1pFUk9fMA__"><span class="b">SEQCNT_ZERO</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span><span class="f">,</span>    \
<a name="268" /><span class="Maybe">     268:</span>         <span class="f">.</span><span class="b">lock</span> <span class="f">=</span>    <a href="cpu.c_macros_ref.html#_X19TUElOX0xPQ0tfVU5MT0NLRURfMA__"><span class="b">__SPIN_LOCK_UNLOCKED</span></a><span class="f">(</span><span class="b">lockname</span><span class="f">)</span>    \
<a name="269" /><span class="Maybe">     269:</span>     <span class="f">}</span>
<a name="270" /><span class="Maybe">     270:</span> 
<a name="271" /><span class="Maybe">     271:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_c2VxbG9ja19pbml0XzA_"><span class="b">seqlock_init</span></a><span class="f">(</span><span class="b">x</span><span class="f">)</span>                    \
<a name="272" /><span class="Maybe">     272:</span>     <span class="m">do</span> <span class="f">{</span>                        \
<a name="273" /><span class="Maybe">     273:</span>         <a href="cpu.c_macros_noref.html#_c2VxY291bnRfaW5pdF8w"><span class="b">seqcount_init</span></a><span class="f">(</span><span class="f">&amp;</span><span class="f">(</span><span class="b">x</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>        \
<a name="274" /><span class="Maybe">     274:</span>         <a href="cpu.c_macros_ref.html#_c3Bpbl9sb2NrX2luaXRfMA__"><span class="b">spin_lock_init</span></a><span class="f">(</span><span class="f">&amp;</span><span class="f">(</span><span class="b">x</span><span class="f">)</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>        \
<a name="275" /><span class="Maybe">     275:</span>     <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="276" /><span class="Maybe">     276:</span> 
<a name="277" /><span class="Maybe">     277:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_REVGSU5FX1NFUUxPQ0tfMA__"><span class="b">DEFINE_SEQLOCK</span></a><span class="f">(</span><span class="b">x</span><span class="f">)</span> \
<a name="278" /><span class="Maybe">     278:</span>         <span class="b">seqlock_t</span> <span class="b">x</span> <span class="f">=</span> <a href="cpu.c_macros_noref.html#_X19TRVFMT0NLX1VOTE9DS0VEXzA_"><span class="b">__SEQLOCK_UNLOCKED</span></a><span class="f">(</span><span class="b">x</span><span class="f">)</span>
<a name="279" /><span class="Maybe">     279:</span> 
<a name="280" /><span class="Maybe">     280:</span> <span class="k">/*</span>
<a name="281" /><span class="Maybe">     281:</span> <span class="k"> * Read side functions for starting and finalizing a read side section.</span>
<a name="282" /><span class="Maybe">     282:</span> <span class="k"> */</span>
<a name="283" /><span class="Maybe">     283:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="b">read_seqbegin</span><span class="f">(</span><span class="m">const</span> <span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="284" /><span class="Maybe">     284:</span> <span class="f">{</span>
<a name="285" /><span class="Maybe">     285:</span>     <span class="m">return</span> <span class="b">read_seqcount_begin</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="286" /><span class="Maybe">     286:</span> <span class="f">}</span>
<a name="287" /><span class="Maybe">     287:</span> 
<a name="288" /><span class="Maybe">     288:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="b">read_seqretry</span><span class="f">(</span><span class="m">const</span> <span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">,</span> <span class="m">unsigned</span> <span class="b">start</span><span class="f">)</span>
<a name="289" /><span class="Maybe">     289:</span> <span class="f">{</span>
<a name="290" /><span class="Maybe">     290:</span>     <span class="m">return</span> <span class="b">read_seqcount_retry</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">,</span> <span class="b">start</span><span class="f">)</span><span class="f">;</span>
<a name="291" /><span class="Maybe">     291:</span> <span class="f">}</span>
<a name="292" /><span class="Maybe">     292:</span> 
<a name="293" /><span class="Maybe">     293:</span> <span class="k">/*</span>
<a name="294" /><span class="Maybe">     294:</span> <span class="k"> * Lock out other writers and update the count.</span>
<a name="295" /><span class="Maybe">     295:</span> <span class="k"> * Acts like a normal spin_lock/unlock.</span>
<a name="296" /><span class="Maybe">     296:</span> <span class="k"> * Don&apos;t need preempt_disable() because that is in the spin_lock already.</span>
<a name="297" /><span class="Maybe">     297:</span> <span class="k"> */</span>
<a name="298" /><span class="Maybe">     298:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqlock</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="299" /><span class="Maybe">     299:</span> <span class="f">{</span>
<a name="300" /><span class="Maybe">     300:</span>     <span class="b">spin_lock</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="301" /><span class="Maybe">     301:</span>     <span class="b">write_seqcount_begin</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="302" /><span class="Maybe">     302:</span> <span class="f">}</span>
<a name="303" /><span class="Maybe">     303:</span> 
<a name="304" /><span class="Maybe">     304:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_sequnlock</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="305" /><span class="Maybe">     305:</span> <span class="f">{</span>
<a name="306" /><span class="Maybe">     306:</span>     <span class="b">write_seqcount_end</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="307" /><span class="Maybe">     307:</span>     <span class="b">spin_unlock</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="308" /><span class="Maybe">     308:</span> <span class="f">}</span>
<a name="309" /><span class="Maybe">     309:</span> 
<a name="310" /><span class="Maybe">     310:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqlock_bh</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="311" /><span class="Maybe">     311:</span> <span class="f">{</span>
<a name="312" /><span class="Maybe">     312:</span>     <span class="b">spin_lock_bh</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="313" /><span class="Maybe">     313:</span>     <span class="b">write_seqcount_begin</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="314" /><span class="Maybe">     314:</span> <span class="f">}</span>
<a name="315" /><span class="Maybe">     315:</span> 
<a name="316" /><span class="Maybe">     316:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_sequnlock_bh</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="317" /><span class="Maybe">     317:</span> <span class="f">{</span>
<a name="318" /><span class="Maybe">     318:</span>     <span class="b">write_seqcount_end</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="319" /><span class="Maybe">     319:</span>     <span class="b">spin_unlock_bh</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="320" /><span class="Maybe">     320:</span> <span class="f">}</span>
<a name="321" /><span class="Maybe">     321:</span> 
<a name="322" /><span class="Maybe">     322:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_seqlock_irq</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="323" /><span class="Maybe">     323:</span> <span class="f">{</span>
<a name="324" /><span class="Maybe">     324:</span>     <span class="b">spin_lock_irq</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="325" /><span class="Maybe">     325:</span>     <span class="b">write_seqcount_begin</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="326" /><span class="Maybe">     326:</span> <span class="f">}</span>
<a name="327" /><span class="Maybe">     327:</span> 
<a name="328" /><span class="Maybe">     328:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">write_sequnlock_irq</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="329" /><span class="Maybe">     329:</span> <span class="f">{</span>
<a name="330" /><span class="Maybe">     330:</span>     <span class="b">write_seqcount_end</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="331" /><span class="Maybe">     331:</span>     <span class="b">spin_unlock_irq</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="332" /><span class="Maybe">     332:</span> <span class="f">}</span>
<a name="333" /><span class="Maybe">     333:</span> 
<a name="334" /><span class="Maybe">     334:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">__write_seqlock_irqsave</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="335" /><span class="Maybe">     335:</span> <span class="f">{</span>
<a name="336" /><span class="Maybe">     336:</span>     <span class="m">unsigned</span> <span class="m">long</span> <span class="b">flags</span><span class="f">;</span>
<a name="337" /><span class="Maybe">     337:</span> 
<a name="338" /><span class="Maybe">     338:</span>     <a href="cpu.c_macros_ref.html#_c3Bpbl9sb2NrX2lycXNhdmVfMA__"><span class="b">spin_lock_irqsave</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="339" /><span class="Maybe">     339:</span>     <span class="b">write_seqcount_begin</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="340" /><span class="Maybe">     340:</span>     <span class="m">return</span> <span class="b">flags</span><span class="f">;</span>
<a name="341" /><span class="Maybe">     341:</span> <span class="f">}</span>
<a name="342" /><span class="Maybe">     342:</span> 
<a name="343" /><span class="Maybe">     343:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_d3JpdGVfc2VxbG9ja19pcnFzYXZlXzA_"><span class="b">write_seqlock_irqsave</span></a><span class="f">(</span><span class="b">lock</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span>                \
<a name="344" /><span class="Maybe">     344:</span>     <span class="m">do</span> <span class="f">{</span> <span class="b">flags</span> <span class="f">=</span> <span class="b">__write_seqlock_irqsave</span><span class="f">(</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span> <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="345" /><span class="Maybe">     345:</span> 
<a name="346" /><span class="Maybe">     346:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span>
<a name="347" /><span class="Maybe">     347:</span> <span class="b">write_sequnlock_irqrestore</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">flags</span><span class="f">)</span>
<a name="348" /><span class="Maybe">     348:</span> <span class="f">{</span>
<a name="349" /><span class="Maybe">     349:</span>     <span class="b">write_seqcount_end</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">seqcount</span><span class="f">)</span><span class="f">;</span>
<a name="350" /><span class="Maybe">     350:</span>     <span class="b">spin_unlock_irqrestore</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="351" /><span class="Maybe">     351:</span> <span class="f">}</span>
<a name="352" /><span class="Maybe">     352:</span> 
<a name="353" /><span class="Maybe">     353:</span> <span class="k">/*</span>
<a name="354" /><span class="Maybe">     354:</span> <span class="k"> * A locking reader exclusively locks out other writers and locking readers,</span>
<a name="355" /><span class="Maybe">     355:</span> <span class="k"> * but doesn&apos;t update the sequence number. Acts like a normal spin_lock/unlock.</span>
<a name="356" /><span class="Maybe">     356:</span> <span class="k"> * Don&apos;t need preempt_disable() because that is in the spin_lock already.</span>
<a name="357" /><span class="Maybe">     357:</span> <span class="k"> */</span>
<a name="358" /><span class="Maybe">     358:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_seqlock_excl</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="359" /><span class="Maybe">     359:</span> <span class="f">{</span>
<a name="360" /><span class="Maybe">     360:</span>     <span class="b">spin_lock</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="361" /><span class="Maybe">     361:</span> <span class="f">}</span>
<a name="362" /><span class="Maybe">     362:</span> 
<a name="363" /><span class="Maybe">     363:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_sequnlock_excl</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="364" /><span class="Maybe">     364:</span> <span class="f">{</span>
<a name="365" /><span class="Maybe">     365:</span>     <span class="b">spin_unlock</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="366" /><span class="Maybe">     366:</span> <span class="f">}</span>
<a name="367" /><span class="Maybe">     367:</span> 
<a name="368" /><span class="Maybe">     368:</span> <span class="k">/**</span>
<a name="369" /><span class="Maybe">     369:</span> <span class="k"> * read_seqbegin_or_lock - begin a sequence number check or locking block</span>
<a name="370" /><span class="Maybe">     370:</span> <span class="k"> * @lock: sequence lock</span>
<a name="371" /><span class="Maybe">     371:</span> <span class="k"> * @seq : sequence number to be checked</span>
<a name="372" /><span class="Maybe">     372:</span> <span class="k"> *</span>
<a name="373" /><span class="Maybe">     373:</span> <span class="k"> * First try it once optimistically without taking the lock. If that fails,</span>
<a name="374" /><span class="Maybe">     374:</span> <span class="k"> * take the lock. The sequence number is also used as a marker for deciding</span>
<a name="375" /><span class="Maybe">     375:</span> <span class="k"> * whether to be a reader (even) or writer (odd).</span>
<a name="376" /><span class="Maybe">     376:</span> <span class="k"> * N.B. seq must be initialized to an even number to begin with.</span>
<a name="377" /><span class="Maybe">     377:</span> <span class="k"> */</span>
<a name="378" /><span class="Maybe">     378:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_seqbegin_or_lock</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">lock</span><span class="f">,</span> <span class="m">int</span> <span class="f">*</span><span class="b">seq</span><span class="f">)</span>
<a name="379" /><span class="Maybe">     379:</span> <span class="f">{</span>
<a name="380" /><span class="Maybe">     380:</span>     <span class="m">if</span> <span class="f">(</span><span class="f">!</span><span class="f">(</span><span class="f">*</span><span class="b">seq</span> <span class="f">&amp;</span> <span class="c">1</span><span class="f">)</span><span class="f">)</span>    <span class="k">/* Even */</span>
<a name="381" /><span class="Maybe">     381:</span>         <span class="f">*</span><span class="b">seq</span> <span class="f">=</span> <span class="b">read_seqbegin</span><span class="f">(</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="382" /><span class="Maybe">     382:</span>     <span class="m">else</span>            <span class="k">/* Odd */</span>
<a name="383" /><span class="Maybe">     383:</span>         <span class="b">read_seqlock_excl</span><span class="f">(</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="384" /><span class="Maybe">     384:</span> <span class="f">}</span>
<a name="385" /><span class="Maybe">     385:</span> 
<a name="386" /><span class="Maybe">     386:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">int</span> <span class="b">need_seqretry</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">lock</span><span class="f">,</span> <span class="m">int</span> <span class="b">seq</span><span class="f">)</span>
<a name="387" /><span class="Maybe">     387:</span> <span class="f">{</span>
<a name="388" /><span class="Maybe">     388:</span>     <span class="m">return</span> <span class="f">!</span><span class="f">(</span><span class="b">seq</span> <span class="f">&amp;</span> <span class="c">1</span><span class="f">)</span> <span class="f">&amp;&amp;</span> <span class="b">read_seqretry</span><span class="f">(</span><span class="b">lock</span><span class="f">,</span> <span class="b">seq</span><span class="f">)</span><span class="f">;</span>
<a name="389" /><span class="Maybe">     389:</span> <span class="f">}</span>
<a name="390" /><span class="Maybe">     390:</span> 
<a name="391" /><span class="Maybe">     391:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">done_seqretry</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">lock</span><span class="f">,</span> <span class="m">int</span> <span class="b">seq</span><span class="f">)</span>
<a name="392" /><span class="Maybe">     392:</span> <span class="f">{</span>
<a name="393" /><span class="Maybe">     393:</span>     <span class="m">if</span> <span class="f">(</span><span class="b">seq</span> <span class="f">&amp;</span> <span class="c">1</span><span class="f">)</span>
<a name="394" /><span class="Maybe">     394:</span>         <span class="b">read_sequnlock_excl</span><span class="f">(</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="395" /><span class="Maybe">     395:</span> <span class="f">}</span>
<a name="396" /><span class="Maybe">     396:</span> 
<a name="397" /><span class="Maybe">     397:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_seqlock_excl_bh</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="398" /><span class="Maybe">     398:</span> <span class="f">{</span>
<a name="399" /><span class="Maybe">     399:</span>     <span class="b">spin_lock_bh</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="400" /><span class="Maybe">     400:</span> <span class="f">}</span>
<a name="401" /><span class="Maybe">     401:</span> 
<a name="402" /><span class="Maybe">     402:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_sequnlock_excl_bh</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="403" /><span class="Maybe">     403:</span> <span class="f">{</span>
<a name="404" /><span class="Maybe">     404:</span>     <span class="b">spin_unlock_bh</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="405" /><span class="Maybe">     405:</span> <span class="f">}</span>
<a name="406" /><span class="Maybe">     406:</span> 
<a name="407" /><span class="Maybe">     407:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_seqlock_excl_irq</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="408" /><span class="Maybe">     408:</span> <span class="f">{</span>
<a name="409" /><span class="Maybe">     409:</span>     <span class="b">spin_lock_irq</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="410" /><span class="Maybe">     410:</span> <span class="f">}</span>
<a name="411" /><span class="Maybe">     411:</span> 
<a name="412" /><span class="Maybe">     412:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span> <span class="b">read_sequnlock_excl_irq</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="413" /><span class="Maybe">     413:</span> <span class="f">{</span>
<a name="414" /><span class="Maybe">     414:</span>     <span class="b">spin_unlock_irq</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span>
<a name="415" /><span class="Maybe">     415:</span> <span class="f">}</span>
<a name="416" /><span class="Maybe">     416:</span> 
<a name="417" /><span class="Maybe">     417:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">__read_seqlock_excl_irqsave</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">)</span>
<a name="418" /><span class="Maybe">     418:</span> <span class="f">{</span>
<a name="419" /><span class="Maybe">     419:</span>     <span class="m">unsigned</span> <span class="m">long</span> <span class="b">flags</span><span class="f">;</span>
<a name="420" /><span class="Maybe">     420:</span> 
<a name="421" /><span class="Maybe">     421:</span>     <a href="cpu.c_macros_ref.html#_c3Bpbl9sb2NrX2lycXNhdmVfMA__"><span class="b">spin_lock_irqsave</span></a><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="422" /><span class="Maybe">     422:</span>     <span class="m">return</span> <span class="b">flags</span><span class="f">;</span>
<a name="423" /><span class="Maybe">     423:</span> <span class="f">}</span>
<a name="424" /><span class="Maybe">     424:</span> 
<a name="425" /><span class="Maybe">     425:</span> <span class="f">#</span><span class="n">define</span> <a href="cpu.c_macros_noref.html#_cmVhZF9zZXFsb2NrX2V4Y2xfaXJxc2F2ZV8w"><span class="b">read_seqlock_excl_irqsave</span></a><span class="f">(</span><span class="b">lock</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span>                \
<a name="426" /><span class="Maybe">     426:</span>     <span class="m">do</span> <span class="f">{</span> <span class="b">flags</span> <span class="f">=</span> <span class="b">__read_seqlock_excl_irqsave</span><span class="f">(</span><span class="b">lock</span><span class="f">)</span><span class="f">;</span> <span class="f">}</span> <span class="m">while</span> <span class="f">(</span><span class="c">0</span><span class="f">)</span>
<a name="427" /><span class="Maybe">     427:</span> 
<a name="428" /><span class="Maybe">     428:</span> <span class="m">static</span> <span class="m">inline</span> <span class="m">void</span>
<a name="429" /><span class="Maybe">     429:</span> <span class="b">read_sequnlock_excl_irqrestore</span><span class="f">(</span><span class="b">seqlock_t</span> <span class="f">*</span><span class="b">sl</span><span class="f">,</span> <span class="m">unsigned</span> <span class="m">long</span> <span class="b">flags</span><span class="f">)</span>
<a name="430" /><span class="Maybe">     430:</span> <span class="f">{</span>
<a name="431" /><span class="Maybe">     431:</span>     <span class="b">spin_unlock_irqrestore</span><span class="f">(</span><span class="f">&amp;</span><span class="b">sl</span><span class="f">-&gt;</span><span class="b">lock</span><span class="f">,</span> <span class="b">flags</span><span class="f">)</span><span class="f">;</span>
<a name="432" /><span class="Maybe">     432:</span> <span class="f">}</span>
<a name="433" /><span class="Maybe">     433:</span> 
<a name="434" /><span class="True">     434:</span> <span class="f">#</span><span class="n">endif</span> <span class="k">/* __LINUX_SEQLOCK_H */</span>
<a name="435" /><span class="True">     435:</span> </pre>
  </body>
</html>
